package com.example.kotlinstudy.类与对象

import android.content.Context
import android.util.AttributeSet
import android.view.View

class Example // 从 Any 隐式继承

open class Base(p: Int) // 该类开放继承

class Derived(p: Int) : Base(p)

class MyView : View {
    constructor(ctx: Context) : super(ctx)
    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

//覆盖方法
open class Shape {
    open fun draw() {}
    fun fill() {}
}

open class Circle() : Shape() {
    override fun draw() {

    }
    //禁止再覆盖
//    final override fun draw() {
//
//    }
}

class CircleChild() : Circle() {
    override fun draw() {
        super.draw()
    }
}

//覆盖属性
open class Shape2 {
    open val vertexCount: Int = 0
}

class Rectangle2 : Shape2() {
    override val vertexCount = 4
}

//你也可以用一个 var 属性覆盖一个 val 属性，但反之则不行。 这是允许的，因为一个 val 属性本质上声明了一个 get 方法， 而将其覆盖为 var 只是在子类中额外声明一个 set 方法。
//请注意，你可以在主构造函数中使用 override 关键字作为属性声明的一部分：
interface Shape3 {
    val vertexCount: Int
}

class Rectangle3(override val vertexCount: Int = 4) : Shape3
class Polygon3 : Shape3 {
    override var vertexCount: Int = 0
}

//派生类初始化顺序
open class Base2(name: String) {
    init {
        println("Initializing a bse class")
    }

    open val size: Int = name.length.also {
        println("Initializing size in the base class: $it")
    }
}

class Derived2(
    name: String,
    lastName: String,
) : Base2(name.replaceFirstChar { it.uppercase() }
    .also { println("Argument for the base class: $it") }) {

    init {
        println("Initializing a derived class")

    }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in the derived class: $it") }
}

fun main() {
    println("Constructing the derived class(\"hello\", \"world\")")
    Derived2("hello", "world")
}

///调用超类实现
//派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现
open class Rectangle4 {
    open fun draw() {
        println("Drawing a rectangle")
    }

    val borderColor: String get() = "black"
}

class FilledRectangle : Rectangle4() {
    override fun draw() {
        super.draw()
        println("Filling the rectangle")
    }

    val fillColor: String get() = super.borderColor
}

//在内部类中访问外部类的超类，可以使用由外部类名限定的super关键字来实现：super@outer
open class Rectangle5 {
    open fun draw() {
        println("Drawing a rectangle")

    }

    val borderColor: String get() = "black"
}

class FilledRectangle5 : Rectangle5() {
    override fun draw() {
        val filler = Filler()
        filler.drawAndFill()
    }

    inner class Filler {
        fun fill() {
            println("Filling")
        }

        fun drawAndFill() {
            super@FilledRectangle5.draw()
            fill()
            println("Drawn a filled rectangle with color ${super@FilledRectangle5.borderColor}")
        }
    }
}

//覆盖规则
open class Rectangle6 {
    open fun draw() { /* …… */
    }
}

interface Polygon6 {
    fun draw() { /* …… */
    } // 接口成员默认就是“open”的
}

class Square() : Rectangle6(), Polygon6 {
    // 编译器要求覆盖 draw()：
    override fun draw() {
        super<Rectangle6>.draw() // 调用 Rectangle.draw()
        super<Polygon6>.draw() // 调用 Polygon.draw()
    }
}